App({
  globalData: {
    // 当前会话
    currentSession: null,
    // 聊天历史
    chatHistory: [],
    // 可用的AI模型
    availableModels: [
      { id: 'gpt-3.5-turbo', name: 'gpt-3.5', hasDeepThinking: false },
      { id: 'gpt-4', name: 'gpt-4', hasDeepThinking: false },
      { id: 'deepseek-v3', name: 'DeepSeek V3', hasDeepThinking: false },
      { id: 'deepseek-r1', name: 'DeepSeek R1', hasDeepThinking: true },
      { id: 'dall-e-3', name: '图像生成模型-3', hasDeepThinking: false, isImageModel: true }
    ],
    // 已启用的模型ID
    enabledModelIds: ['deepseek-v3', 'deepseek-r1', 'dall-e-3'],
    // 是否正在加载
    isLoading: false,
    // 是否启用深度思考
    deepThinkingEnabled: false,
    // 是否启用适老化模式
    elderlyModeEnabled: false,
    // 默认模型ID
    DEFAULT_MODEL_ID: 'deepseek-v3',
    // API基础URL
    apiBaseUrl: 'https://protoxhy.com:1443/api'
  },
  
  onLaunch() {
    // 加载本地存储的设置
    this.loadSettings();
    // 加载聊天历史
    this.loadChatHistory();
    // 如果没有当前会话，创建一个新会话
    if (!this.globalData.currentSession) {
      this.createNewSession();
    }
  },
  
  // 加载设置
  loadSettings() {
    const elderlyMode = wx.getStorageSync('elderlyModeEnabled');
    if (elderlyMode !== '') {
      this.globalData.elderlyModeEnabled = elderlyMode;
    }
    
    const deepThinking = wx.getStorageSync('deepThinkingEnabled');
    if (deepThinking !== '') {
      this.globalData.deepThinkingEnabled = deepThinking;
    }
    
    const enabledModels = wx.getStorageSync('enabledModelIds');
    if (enabledModels && enabledModels.length > 0) {
      this.globalData.enabledModelIds = enabledModels;
    }
  },
  
  // 保存设置
  saveSettings() {
    wx.setStorageSync('elderlyModeEnabled', this.globalData.elderlyModeEnabled);
    wx.setStorageSync('deepThinkingEnabled', this.globalData.deepThinkingEnabled);
    wx.setStorageSync('enabledModelIds', this.globalData.enabledModelIds);
  },
  
  // 加载聊天历史
  loadChatHistory() {
    const history = wx.getStorageSync('chatHistory');
    if (history) {
      // 处理历史数据，为缺少model字段的消息添加模型信息
      history.forEach(session => {
        if (session.messages && session.messages.length > 0) {
          session.messages.forEach(msg => {
            // 为AI消息添加模型信息（如果缺少）
            if (msg.role === 'assistant' && !msg.model && session.model) {
              msg.model = session.model;
            }
          });
        }
      });
      
      this.globalData.chatHistory = history;
      
      // 加载当前会话
      const currentSessionId = wx.getStorageSync('currentSessionId');
      if (currentSessionId) {
        const session = this.globalData.chatHistory.find(s => s.id === currentSessionId);
        if (session) {
          this.globalData.currentSession = session;
          return;
        }
      }
    }
  },
  
  // 保存聊天历史
  saveChatHistory() {
    wx.setStorageSync('chatHistory', this.globalData.chatHistory);
    if (this.globalData.currentSession) {
      wx.setStorageSync('currentSessionId', this.globalData.currentSession.id);
    }
  },
  
  // 创建新会话
  createNewSession(modelId) {
    const id = 'session_' + Date.now();
    const model = modelId || this.globalData.DEFAULT_MODEL_ID;
    const session = {
      id: id,
      title: '新对话',
      model: model,
      messages: [],
      createdAt: Date.now(),
      updatedAt: Date.now()
    };
    
    this.globalData.currentSession = session;
    this.globalData.chatHistory.unshift(session);
    this.saveChatHistory();
    return session;
  },
  
  // 发送消息（已废弃，由页面直接调用sendMessageToAPI）
  sendMessage(content, callback) {
    console.log('App.sendMessage 被调用，内容:', content);
    
    if (!content.trim() || this.globalData.isLoading) {
      console.log('无法发送: 内容为空或正在加载');
      return;
    }
    
    // 确保有当前会话
    if (!this.globalData.currentSession) {
      this.createNewSession();
    }
    
    // 添加用户消息
    const userMessage = {
      role: 'user',
      content: content,
      timestamp: Date.now()
    };
    
    this.globalData.currentSession.messages.push(userMessage);
    this.globalData.currentSession.updatedAt = Date.now();
    this.saveChatHistory();
    
    // 设置加载状态
    this.globalData.isLoading = true;
    
    // 调用新方法发送API请求
    this.sendMessageToAPI(content, (err, response) => {
      // 在回调中处理结果
      this.globalData.isLoading = false;
      
      if (callback) {
        callback(err, response);
      }
    });
  },
  
  // 仅发送API请求
  sendMessageToAPI(content, callback) {
    console.log('发送API请求，内容:', content);
    
    if (!this.globalData.currentSession) {
      console.error('没有当前会话');
      // 确保隐藏loading
      wx.hideLoading();
      if (callback) {
        callback(new Error('没有当前会话'), null);
      }
      return;
    }
    
    // 记录请求开始时间
    this.requestStartTime = Date.now();
    
    // 获取当前模型信息
    const currentModel = this.globalData.availableModels.find(m => m.id === this.globalData.currentSession.model);
    
    // 如果是图片生成模型
    if (currentModel && currentModel.isImageModel) {
      // 准备图片生成请求数据
      const requestData = {
        model: "dall-e-3",
        prompt: content,
        n: 1,
        quality: "standard",
        response_format: "url",
        size: "1024x1024",
        style: "natural"
      };
      
      console.log('发送图片生成请求:', 'https://4.0.wokaai.com/v1/images/generations', requestData);
      
      // 发送图片生成API请求
      wx.request({
        url: 'https://4.0.wokaai.com/v1/images/generations',
        method: 'POST',
        data: requestData,
        header: {
          'content-type': 'application/json',
          'Authorization': 'Bearer sk-zMtcC2EFOaQyclovlYumnBJri4FZ5FjH5Jd5v3Jixdt2Knz1'
        },
        success: (res) => {
          console.log('API响应:', res);
          if (res.statusCode === 200) {
            // 从返回的数据中获取图片URL
            const imageUrl = res.data.data[0].url;
            
            // 计算响应耗时（秒，保留1位小数）
            const responseTime = ((Date.now() - this.requestStartTime) / 1000).toFixed(1);
            
            // 添加AI回复（包含图片URL）
            const aiMessage = {
              role: 'assistant',
              content: imageUrl,
              timestamp: Date.now(),
              isImage: true,
              model: this.globalData.currentSession.model,
              responseTime: parseFloat(responseTime)
            };
            
            this.globalData.currentSession.messages.push(aiMessage);
            this.globalData.currentSession.updatedAt = Date.now();
            
            // 如果是第一条消息，更新会话标题
            if (this.globalData.currentSession.messages.length === 2) {
              this.globalData.currentSession.title = content.substring(0, 20) + (content.length > 20 ? '...' : '');
            }
            
            this.saveChatHistory();
            
            if (callback) {
              callback(null, aiMessage);
            }
          } else {
            console.error('图片生成API请求成功但返回错误:', res.data);
            // 添加错误消息到聊天记录
            const errorMessage = {
              role: 'assistant',
              content: res.data.error?.message || '图片生成失败',
              timestamp: Date.now(),
              isError: true,
              model: this.globalData.currentSession.model
            };
            
            this.globalData.currentSession.messages.push(errorMessage);
            this.globalData.currentSession.updatedAt = Date.now();
            this.saveChatHistory();
            
            if (callback) {
              callback(null, errorMessage);
            }
          }
        },
        fail: (err) => {
          console.error('图片生成API请求失败:', err);
          if (callback) {
            callback(err, null);
          }
        }
      });
      return;
    }
    
    // 如果是普通聊天模型，使用原有的请求逻辑
    const requestData = {
      model: this.globalData.currentSession.model,
      messages: this.globalData.currentSession.messages.map(msg => ({
        role: msg.role,
        content: msg.content
      })),
      deep_thinking: this.globalData.deepThinkingEnabled
    };
    
    console.log('发送API请求:', this.globalData.apiBaseUrl + '/chat', requestData);
    
    // 发送API请求
    wx.request({
      url: this.globalData.apiBaseUrl + '/chat',
      method: 'POST',
      data: requestData,
      header: {
        'content-type': 'application/json'
      },
      success: (res) => {
        console.log('API响应:', res);
        if (res.statusCode === 200 && res.data.success) {
          // 调试输出，查看完整响应数据结构
          console.log('API响应数据:', JSON.stringify(res.data.data));
          console.log('响应时间字段:', res.data.data.response_time);
          
          // 处理AI回复内容，去除开头的回车符号
          let aiContent = res.data.data.content;
          // 去除开头的回车符号
          aiContent = aiContent.replace(/^[\r\n]+/, '');
          
          // 计算响应耗时（秒，保留1位小数）
          let responseTimeValue;
          if (res.data.data.response_time !== undefined) {
            // 如果API返回了响应时间，使用API返回的值
            responseTimeValue = res.data.data.response_time;
          } else if (res.data.data.responseTime !== undefined) {
            // 有些API可能用responseTime而不是response_time
            responseTimeValue = res.data.data.responseTime;
          } else {
            // 都没有的话，使用当前时间减去请求开始时间的估算值
            const estimatedTime = ((Date.now() - this.requestStartTime) / 1000).toFixed(1);
            responseTimeValue = parseFloat(estimatedTime);
          }
          
          // 添加AI回复
          const aiMessage = {
            role: 'assistant',
            content: aiContent,
            timestamp: Date.now(),
            tokens: res.data.data.tokens,
            promptTokens: res.data.data.prompt_tokens,
            completionTokens: res.data.data.completion_tokens,
            responseTime: responseTimeValue,
            model: this.globalData.currentSession.model
          };
          
          this.globalData.currentSession.messages.push(aiMessage);
          this.globalData.currentSession.updatedAt = Date.now();
          
          // 如果是第一条消息，更新会话标题
          if (this.globalData.currentSession.messages.length === 2) {
            this.globalData.currentSession.title = content.substring(0, 20) + (content.length > 20 ? '...' : '');
          }
          
          this.saveChatHistory();
          
          if (callback) {
            callback(null, aiMessage);
          }
        } else {
          console.error('API请求成功但返回错误:', res.data);
          if (callback) {
            callback(new Error('请求失败: ' + (res.data.message || '未知错误')), null);
          }
        }
      },
      fail: (err) => {
        console.error('API请求失败:', err);
        if (callback) {
          callback(err, null);
        }
      },
      complete: () => {
        // 不在这里设置isLoading状态，由页面自己处理
      }
    });
  },
  
  // 切换会话
  switchSession(sessionId) {
    const session = this.globalData.chatHistory.find(s => s.id === sessionId);
    if (session) {
      this.globalData.currentSession = session;
      wx.setStorageSync('currentSessionId', sessionId);
      return true;
    }
    return false;
  },
  
  // 删除会话
  deleteSession(sessionId) {
    const index = this.globalData.chatHistory.findIndex(s => s.id === sessionId);
    if (index !== -1) {
      this.globalData.chatHistory.splice(index, 1);
      
      // 如果删除的是当前会话，切换到第一个会话或创建新会话
      if (this.globalData.currentSession && this.globalData.currentSession.id === sessionId) {
        if (this.globalData.chatHistory.length > 0) {
          this.globalData.currentSession = this.globalData.chatHistory[0];
        } else {
          this.createNewSession();
        }
      }
      
      this.saveChatHistory();
      return true;
    }
    return false;
  },
  
  // 清空所有历史
  clearAllHistory() {
    this.globalData.chatHistory = [];
    this.createNewSession();
    this.saveChatHistory();
  }
}) 